package com.laoli.utils;

import com.laoli.entity.JobBean;
import org.quartz.*;

public class JobUtils{

    /**
     * 生成一个定时任务
     * @param scheduler 调度器
     * @param jobBean 任务Bean
     */
    public static void createJob(Scheduler scheduler,JobBean jobBean){
        Class<? extends Job> jobClass = null;
        JobDetail jobDetail = null;
        Trigger trigger = null;
        String croExpression = "0/2 * * * * ? *";      //每隔2秒执行一次（时间频率）


        try {
            jobClass = (Class<? extends Job>) Class.forName(jobBean.getJobClass());
            jobDetail = JobBuilder.newJob(jobClass)//将当前JobDetail实例与自定义任务MyJob绑定
                    .storeDurably() //开启任务持久化
                    .withIdentity(jobBean.getJobName())  //设置任务详情的唯一标识,这里是直接用任务名字作为唯一标识了
                    .usingJobData("count",1)        //(共享)数据初始化，这些数据会在任务多次被执行过程中被共享
                    .build();
            trigger = TriggerBuilder.newTrigger()
                    .forJob(jobDetail)
                    .withIdentity(jobBean.getJobName()+"_trigger")  //触发器唯一标识
                    .withSchedule(CronScheduleBuilder.cronSchedule(jobBean.getCronExpression()))
                    .build();
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }


        try {
            scheduler.scheduleJob(jobDetail,trigger);
        } catch (SchedulerException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 暂停一个定时任务
     * @param scheduler 调度器
     * @param jobName 任务名字
     */
    public static void pauseJob(Scheduler scheduler,String jobName){
        JobKey jobKey = JobKey.jobKey(jobName);//之前设置了jobName就是任务Job的唯一标识，这里暂停任务需要传入的就是任务的唯一标识，也就是jobname
        try {
            scheduler.pauseJob(jobKey);
        } catch (SchedulerException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 恢复一个定时任务
     * @param scheduler 调度器
     * @param jobName 任务名字
     */
    public static void resumeJob(Scheduler scheduler,String jobName){
        JobKey jobKey = JobKey.jobKey(jobName);//之前设置了jobName就是任务Job的唯一标识，这里暂停任务需要传入的就是任务的唯一标识，也就是jobname
        try {
            scheduler.resumeJob(jobKey);
        } catch (SchedulerException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 删除一个定时任务
     * @param scheduler 调度器
     * @param jobName 任务名字
     */
    public static void deleteJob(Scheduler scheduler,String jobName){
        JobKey jobKey = JobKey.jobKey(jobName);//之前设置了jobName就是任务Job的唯一标识，这里暂停任务需要传入的就是任务的唯一标识，也就是jobname
        try {
            scheduler.deleteJob(jobKey);
        } catch (SchedulerException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 运行一个定时任务一次
     * @param scheduler 调度器
     * @param jobName 任务名字
     */
    public static void runJobOnce(Scheduler scheduler,String jobName){
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.triggerJob(jobKey);
        } catch (SchedulerException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 修改一个定时任务（是修改执行时间）
     * @param scheduler 调度器
     * @param jobBean 任务Bean
     */
    public static void modifyJob(Scheduler scheduler,JobBean jobBean){
        //获取任务触发器的唯一标识
        TriggerKey triggerKey = TriggerKey.triggerKey(jobBean.getJobName() + "_trigger");

        try {
            //通过唯一标识获取旧的触发器对象
            CronTrigger oldTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            //使用新cron表达式构建新的触发器
            String newCron = jobBean.getCronExpression();
            CronTrigger newTrigger = oldTrigger.getTriggerBuilder()
                    .withSchedule(CronScheduleBuilder.cronSchedule(newCron).withMisfireHandlingInstructionDoNothing())
                    .build();
            //调度器更新任务的触发器
            scheduler.rescheduleJob(triggerKey,newTrigger);
        } catch (SchedulerException e) {
            throw new RuntimeException(e);
        }



    }
}
